home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 1999 #5 / 1999 CD 5 (black).iso / Delphi3 / install / data.z / WINSVC.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1997-08-04  |  18.8 KB  |  440 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Run-time Library                         }
  5. {       Windows 32bit API Interface Unit                }
  6. {                                                       }
  7. {       Copyright (c) 1996,97 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit WinSvc;
  12.  
  13. {$ALIGN ON}
  14. {$MINENUMSIZE 4}
  15. {$WEAKPACKAGEUNIT}
  16.  
  17. interface
  18.  
  19. uses Windows;
  20.  
  21. //
  22. // Constants
  23. //
  24.  
  25. const
  26.  
  27. //
  28. // Service database names
  29. //
  30.   SERVICES_ACTIVE_DATABASEA     = 'ServicesActive';
  31.   SERVICES_ACTIVE_DATABASEW     = 'ServicesActive';
  32.   SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
  33.   SERVICES_FAILED_DATABASEA     = 'ServicesFailed';
  34.   SERVICES_FAILED_DATABASEW     = 'ServicesFailed';
  35.   SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
  36.  
  37. //
  38. // Character to designate that a name is a group
  39. //
  40.   SC_GROUP_IDENTIFIERA          = '+';
  41.   SC_GROUP_IDENTIFIERW          = '+';
  42.   SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
  43.  
  44. //
  45. // Value to indicate no change to an optional parameter
  46. //
  47.   SERVICE_NO_CHANGE              = $FFFFFFFF;
  48.  
  49. //
  50. // Service State -- for Enum Requests (Bit Mask)
  51. //
  52.   SERVICE_ACTIVE                 = $00000001;
  53.   SERVICE_INACTIVE               = $00000002;
  54.   SERVICE_STATE_ALL              = (SERVICE_ACTIVE   or
  55.                                     SERVICE_INACTIVE);
  56.  
  57. //
  58. // Controls
  59. //
  60.   SERVICE_CONTROL_STOP           = $00000001;
  61.   SERVICE_CONTROL_PAUSE          = $00000002;
  62.   SERVICE_CONTROL_CONTINUE       = $00000003;
  63.   SERVICE_CONTROL_INTERROGATE    = $00000004;
  64.   SERVICE_CONTROL_SHUTDOWN       = $00000005;
  65.  
  66. //
  67. // Service State -- for CurrentState
  68. //
  69.   SERVICE_STOPPED                = $00000001;
  70.   SERVICE_START_PENDING          = $00000002;
  71.   SERVICE_STOP_PENDING           = $00000003;
  72.   SERVICE_RUNNING                = $00000004;
  73.   SERVICE_CONTINUE_PENDING       = $00000005;
  74.   SERVICE_PAUSE_PENDING          = $00000006;
  75.   SERVICE_PAUSED                 = $00000007;
  76.  
  77. //
  78. // Controls Accepted  (Bit Mask)
  79. //
  80.   SERVICE_ACCEPT_STOP            = $00000001;
  81.   SERVICE_ACCEPT_PAUSE_CONTINUE  = $00000002;
  82.   SERVICE_ACCEPT_SHUTDOWN        = $00000004;
  83.  
  84. //
  85. // Service Control Manager object specific access types
  86. //
  87.   SC_MANAGER_CONNECT             = $0001;
  88.   SC_MANAGER_CREATE_SERVICE      = $0002;
  89.   SC_MANAGER_ENUMERATE_SERVICE   = $0004;
  90.   SC_MANAGER_LOCK                = $0008;
  91.   SC_MANAGER_QUERY_LOCK_STATUS   = $0010;
  92.   SC_MANAGER_MODIFY_BOOT_CONFIG  = $0020;
  93.  
  94.   SC_MANAGER_ALL_ACCESS          = (STANDARD_RIGHTS_REQUIRED or
  95.                                     SC_MANAGER_CONNECT or
  96.                                     SC_MANAGER_CREATE_SERVICE or
  97.                                     SC_MANAGER_ENUMERATE_SERVICE or
  98.                                     SC_MANAGER_LOCK or
  99.                                     SC_MANAGER_QUERY_LOCK_STATUS or
  100.                                     SC_MANAGER_MODIFY_BOOT_CONFIG);
  101.  
  102. //
  103. // Service object specific access type
  104. //
  105.   SERVICE_QUERY_CONFIG           = $0001;
  106.   SERVICE_CHANGE_CONFIG          = $0002;
  107.   SERVICE_QUERY_STATUS           = $0004;
  108.   SERVICE_ENUMERATE_DEPENDENTS   = $0008;
  109.   SERVICE_START                  = $0010;
  110.   SERVICE_STOP                   = $0020;
  111.   SERVICE_PAUSE_CONTINUE         = $0040;
  112.   SERVICE_INTERROGATE            = $0080;
  113.   SERVICE_USER_DEFINED_CONTROL   = $0100;
  114.  
  115.   SERVICE_ALL_ACCESS             = (STANDARD_RIGHTS_REQUIRED or
  116.                                     SERVICE_QUERY_CONFIG or
  117.                                     SERVICE_CHANGE_CONFIG or
  118.                                     SERVICE_QUERY_STATUS or
  119.                                     SERVICE_ENUMERATE_DEPENDENTS or
  120.                                     SERVICE_START or
  121.                                     SERVICE_STOP or
  122.                                     SERVICE_PAUSE_CONTINUE or
  123.                                     SERVICE_INTERROGATE or
  124.                                     SERVICE_USER_DEFINED_CONTROL);
  125.  
  126.  
  127. type
  128.  
  129. //
  130. // Handle Types
  131. //
  132.  
  133.   SC_HANDLE = THandle;
  134.   LPSC_HANDLE = ^SC_HANDLE;
  135.  
  136.   SERVICE_STATUS_HANDLE = DWORD;
  137.  
  138. //
  139. // pointer to string pointer
  140. //
  141.  
  142.   PLPSTRA = ^PAnsiChar;
  143.   PLPSTRW = ^PWideChar;
  144.   PLPSTR = PLPSTRA;
  145.  
  146. //
  147. // Service Status Structure
  148. //
  149.  
  150.   PServiceStatus = ^TServiceStatus;
  151.   TServiceStatus = record
  152.     dwServiceType: DWORD;
  153.     dwCurrentState: DWORD;
  154.     dwControlsAccepted: DWORD;
  155.     dwWin32ExitCode: DWORD;
  156.     dwServiceSpecificExitCode: DWORD;
  157.     dwCheckPoint: DWORD;
  158.     dwWaitHint: DWORD;
  159.   end;
  160.  
  161. //
  162. // Service Status Enumeration Structure
  163. //
  164.   PEnumServiceStatusA = ^TEnumServiceStatusA;
  165.   PEnumServiceStatusW = ^TEnumServiceStatusW;
  166.   PEnumServiceStatus = PEnumServiceStatusA;
  167.   TEnumServiceStatusA = record
  168.     lpServiceName: PAnsiChar;
  169.     lpDisplayName: PAnsiChar;
  170.     ServiceStatus: TServiceStatus;
  171.   end;
  172.   TEnumServiceStatusW = record
  173.     lpServiceName: PWideChar;
  174.     lpDisplayName: PWideChar;
  175.     ServiceStatus: TServiceStatus;
  176.   end;
  177.   TEnumServiceStatus = TEnumServiceStatusA;
  178.  
  179. //
  180. // Structures for the Lock API functions
  181. //
  182.   SC_LOCK = Pointer;
  183.   PQueryServiceLockStatusA = ^TQueryServiceLockStatusA;
  184.   PQueryServiceLockStatusW = ^TQueryServiceLockStatusW;
  185.   PQueryServiceLockStatus = PQueryServiceLockStatusA;
  186.   TQueryServiceLockStatusA = record
  187.     fIsLocked: DWORD;
  188.     lpLockOwner: PAnsiChar;
  189.     dwLockDuration: DWORD;
  190.   end;
  191.   TQueryServiceLockStatusW = record
  192.     fIsLocked: DWORD;
  193.     lpLockOwner: PWideChar;
  194.     dwLockDuration: DWORD;
  195.   end;
  196.   TQueryServiceLockStatus = TQueryServiceLockStatusA;
  197.  
  198. //
  199. // Query Service Configuration Structure
  200. //
  201.   PQueryServiceConfigA = ^TQueryServiceConfigA;
  202.   PQueryServiceConfigW = ^TQueryServiceConfigW;
  203.   PQueryServiceConfig = PQueryServiceConfigA;
  204.   TQueryServiceConfigA = record
  205.     dwServiceType: DWORD;
  206.     dwStartType: DWORD;
  207.     dwErrorControl: DWORD;
  208.     lpBinaryPathName: PAnsiChar;
  209.     lpLoadOrderGroup: PAnsiChar;
  210.     dwTagId: DWORD;
  211.     lpDependencies: PAnsiChar;
  212.     lpServiceStartName: PAnsiChar;
  213.     lpDisplayName: PAnsiChar;
  214.   end;
  215.   TQueryServiceConfigW = record
  216.     dwServiceType: DWORD;
  217.     dwStartType: DWORD;
  218.     dwErrorControl: DWORD;
  219.     lpBinaryPathName: PWideChar;
  220.     lpLoadOrderGroup: PWideChar;
  221.     dwTagId: DWORD;
  222.     lpDependencies: PWideChar;
  223.     lpServiceStartName: PWideChar;
  224.     lpDisplayName: PWideChar;
  225.   end;
  226.   TQueryServiceConfig = TQueryServiceConfigA;
  227.  
  228. //
  229. // Function Prototype for the Service Main Function
  230. //
  231.  
  232.   TServiceMainFunctionA = TFarProc;
  233.   TServiceMainFunctionW = TFarProc;
  234.   TServiceMainFunction = TServiceMainFunctionA;
  235.  
  236. //
  237. // Service Start Table
  238. //
  239.   PServiceTableEntryA = ^TServiceTableEntryA;
  240.   PServiceTableEntryW = ^TServiceTableEntryW;
  241.   PServiceTableEntry = PServiceTableEntryA;
  242.   TServiceTableEntryA = record
  243.     lpServiceName: PAnsiChar;
  244.     lpServiceProc: TServiceMainFunctionA;
  245.   end;
  246.   TServiceTableEntryW = record
  247.     lpServiceName: PWideChar;
  248.     lpServiceProc: TServiceMainFunctionW;
  249.   end;
  250.   TServiceTableEntry = TServiceTableEntryA;
  251.  
  252. //
  253. // Prototype for the Service Control Handler Function
  254. //
  255.  
  256.   THandlerFunction = TFarProc;
  257.  
  258. ///////////////////////////////////////////////////////////////////////////
  259. // API Function Prototypes
  260. ///////////////////////////////////////////////////////////////////////////
  261.  
  262. function ChangeServiceConfigA(hService: SC_HANDLE; dwServiceType, dwStartType,
  263.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PAnsiChar;
  264.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  265.   lpDisplayName: PAnsiChar): BOOL; stdcall;
  266. function ChangeServiceConfigW(hService: SC_HANDLE; dwServiceType, dwStartType,
  267.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PWideChar;
  268.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  269.   lpDisplayName: PWideChar): BOOL; stdcall;
  270. function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
  271.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: PChar;
  272.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  273.   lpDisplayName: PChar): BOOL; stdcall;
  274. function CloseServiceHandle(hSCObject: SC_HANDLE): BOOL; stdcall;
  275. function ControlService(hService: SC_HANDLE; dwControl: DWORD;
  276.   var lpServiceStatus: TServiceStatus): BOOL; stdcall;
  277. function CreateServiceA(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PAnsiChar;
  278.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  279.   lpBinaryPathName, lpLoadOrderGroup: PAnsiChar; lpdwTagId: LPDWORD; lpDependencies,
  280.   lpServiceStartName, lpPassword: PAnsiChar): SC_HANDLE; stdcall;
  281. function CreateServiceW(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PWideChar;
  282.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  283.   lpBinaryPathName, lpLoadOrderGroup: PWideChar; lpdwTagId: LPDWORD; lpDependencies,
  284.   lpServiceStartName, lpPassword: PWideChar): SC_HANDLE; stdcall;
  285. function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: PChar;
  286.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  287.   lpBinaryPathName, lpLoadOrderGroup: PChar; lpdwTagId: LPDWORD; lpDependencies,
  288.   lpServiceStartName, lpPassword: PChar): SC_HANDLE; stdcall;
  289. function DeleteService(hService: SC_HANDLE): BOOL; stdcall;
  290. function EnumDependentServicesA(hService: SC_HANDLE; dwServiceState: DWORD;
  291.   var lpServices: TEnumServiceStatusA; cbBufSize: DWORD; var pcbBytesNeeded,
  292.   lpServicesReturned : DWORD): BOOL; stdcall;
  293. function EnumDependentServicesW(hService: SC_HANDLE; dwServiceState: DWORD;
  294.   var lpServices: TEnumServiceStatusW; cbBufSize: DWORD; var pcbBytesNeeded,
  295.   lpServicesReturned : DWORD): BOOL; stdcall;
  296. function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
  297.   var lpServices: TEnumServiceStatus; cbBufSize: DWORD; var pcbBytesNeeded,
  298.   lpServicesReturned : DWORD): BOOL; stdcall;
  299. function EnumServicesStatusA(hSCManager: SC_HANDLE; dwServiceType,
  300.   dwServiceState: DWORD; var lpServices: TEnumServiceStatusA; cbBufSize: DWORD;
  301.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  302. function EnumServicesStatusW(hSCManager: SC_HANDLE; dwServiceType,
  303.   dwServiceState: DWORD; var lpServices: TEnumServiceStatusW; cbBufSize: DWORD;
  304.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  305. function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType,
  306.   dwServiceState: DWORD; var lpServices: TEnumServiceStatus; cbBufSize: DWORD;
  307.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  308. function GetServiceKeyNameA(hSCManager: SC_HANDLE; lpDisplayName,
  309.   lpServiceName: PAnsiChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  310. function GetServiceKeyNameW(hSCManager: SC_HANDLE; lpDisplayName,
  311.   lpServiceName: PWideChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  312. function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName,
  313.   lpServiceName: PChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  314. function GetServiceDisplayNameA(hSCManager: SC_HANDLE; lpServiceName,
  315.   lpDisplayName: PAnsiChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  316. function GetServiceDisplayNameW(hSCManager: SC_HANDLE; lpServiceName,
  317.   lpDisplayName: PWideChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  318. function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName,
  319.   lpDisplayName: PChar; var lpcchBuffer: DWORD): BOOL; stdcall;
  320. function LockServiceDatabase(hSCManager: SC_HANDLE): SC_LOCK; stdcall;
  321. function NotifyBootConfigStatus(BootAcceptable: BOOL): BOOL; stdcall;
  322. function OpenSCManagerA(lpMachineName, lpDatabaseName: PAnsiChar;
  323.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  324. function OpenSCManagerW(lpMachineName, lpDatabaseName: PWideChar;
  325.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  326. function OpenSCManager(lpMachineName, lpDatabaseName: PChar;
  327.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  328. function OpenServiceA(hSCManager: SC_HANDLE; lpServiceName: PAnsiChar;
  329.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  330. function OpenServiceW(hSCManager: SC_HANDLE; lpServiceName: PWideChar;
  331.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  332. function OpenService(hSCManager: SC_HANDLE; lpServiceName: PChar;
  333.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  334. function QueryServiceConfigA(hService: SC_HANDLE;
  335.   var lpServiceConfig: TQueryServiceConfigA; cbBufSize: DWORD;
  336.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  337. function QueryServiceConfigW(hService: SC_HANDLE;
  338.   var lpServiceConfig: TQueryServiceConfigW; cbBufSize: DWORD;
  339.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  340. function QueryServiceConfig(hService: SC_HANDLE;
  341.   var lpServiceConfig: TQueryServiceConfig; cbBufSize: DWORD;
  342.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  343. function QueryServiceLockStatusA(hSCManager: SC_HANDLE;
  344.   var lpLockStatus: TQueryServiceLockStatusA; cbBufSize: DWORD;
  345.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  346. function QueryServiceLockStatusW(hSCManager: SC_HANDLE;
  347.   var lpLockStatus: TQueryServiceLockStatusW; cbBufSize: DWORD;
  348.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  349. function QueryServiceLockStatus(hSCManager: SC_HANDLE;
  350.   var lpLockStatus: TQueryServiceLockStatus; cbBufSize: DWORD;
  351.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  352. function QueryServiceObjectSecurity(hService: SC_HANDLE;
  353.   dwSecurityInformation: SECURITY_INFORMATION;
  354.   lpSecurityDescriptor: PSECURITY_DESCRIPTOR; cbBufSize: DWORD;
  355.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  356. function QueryServiceStatus(hService: SC_HANDLE; var
  357.   lpServiceStatus: TServiceStatus): BOOL; stdcall;
  358. function RegisterServiceCtrlHandlerA(lpServiceName: PAnsiChar;
  359.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  360. function RegisterServiceCtrlHandlerW(lpServiceName: PWideChar;
  361.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  362. function RegisterServiceCtrlHandler(lpServiceName: PChar;
  363.   lpHandlerProc: ThandlerFunction): SERVICE_STATUS_HANDLE; stdcall;
  364. function SetServiceObjectSecurity(hService: SC_HANDLE;
  365.   dwSecurityInformation: SECURITY_INFORMATION;
  366.   lpSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
  367. function SetServiceStatus(hServiceStatus: SERVICE_STATUS_HANDLE;
  368.   var lpServiceStatus: TServiceStatus): BOOL; stdcall;
  369. function StartServiceCtrlDispatcherA(
  370.   var lpServiceStartTable: TServiceTableEntryA): BOOL; stdcall;
  371. function StartServiceCtrlDispatcherW(
  372.   var lpServiceStartTable: TServiceTableEntryW): BOOL; stdcall;
  373. function StartServiceCtrlDispatcher(
  374.   var lpServiceStartTable: TServiceTableEntry): BOOL; stdcall;
  375. function StartServiceA(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  376.   var lpServiceArgVectors: PAnsiChar): BOOL; stdcall;
  377. function StartServiceW(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  378.   var lpServiceArgVectors: PWideChar): BOOL; stdcall;
  379. function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  380.   var lpServiceArgVectors: PChar): BOOL; stdcall;
  381. function UnlockServiceDatabase(ScLock: SC_LOCK): BOOL; stdcall;
  382.  
  383. implementation
  384.  
  385. const
  386.   advapi32 = 'advapi32.dll';
  387.  
  388. function ChangeServiceConfigA;   external advapi32 name 'ChangeServiceConfigA';
  389. function ChangeServiceConfigW;   external advapi32 name 'ChangeServiceConfigW';
  390. function ChangeServiceConfig;   external advapi32 name 'ChangeServiceConfigA';
  391. function CloseServiceHandle;       external advapi32 name 'CloseServiceHandle';
  392. function ControlService;           external advapi32 name 'ControlService';
  393. function CreateServiceA;         external advapi32 name 'CreateServiceA';
  394. function CreateServiceW;         external advapi32 name 'CreateServiceW';
  395. function CreateService;         external advapi32 name 'CreateServiceA';
  396. function DeleteService;            external advapi32 name 'DeleteService';
  397. function EnumDependentServicesA; external advapi32 name 'EnumDependentServicesA';
  398. function EnumDependentServicesW; external advapi32 name 'EnumDependentServicesW';
  399. function EnumDependentServices; external advapi32 name 'EnumDependentServicesA';
  400. function EnumServicesStatusA;    external advapi32 name 'EnumServicesStatusA';
  401. function EnumServicesStatusW;    external advapi32 name 'EnumServicesStatusW';
  402. function EnumServicesStatus;    external advapi32 name 'EnumServicesStatusA';
  403. function GetServiceKeyNameA;     external advapi32 name 'GetServiceKeyNameA';
  404. function GetServiceKeyNameW;     external advapi32 name 'GetServiceKeyNameW';
  405. function GetServiceKeyName;     external advapi32 name 'GetServiceKeyNameA';
  406. function GetServiceDisplayNameA; external advapi32 name 'GetServiceDisplayNameA';
  407. function GetServiceDisplayNameW; external advapi32 name 'GetServiceDisplayNameW';
  408. function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayNameA';
  409. function LockServiceDatabase;      external advapi32 name 'LockServiceDatabase';
  410. function NotifyBootConfigStatus;   external advapi32 name 'NotifyBootConfigStatus';
  411. function OpenSCManagerA;         external advapi32 name 'OpenSCManagerA';
  412. function OpenSCManagerW;         external advapi32 name 'OpenSCManagerW';
  413. function OpenSCManager;         external advapi32 name 'OpenSCManagerA';
  414. function OpenServiceA;           external advapi32 name 'OpenServiceA';
  415. function OpenServiceW;           external advapi32 name 'OpenServiceW';
  416. function OpenService;           external advapi32 name 'OpenServiceA';
  417. function QueryServiceConfigA;    external advapi32 name 'QueryServiceConfigA';
  418. function QueryServiceConfigW;    external advapi32 name 'QueryServiceConfigW';
  419. function QueryServiceConfig;    external advapi32 name 'QueryServiceConfigA';
  420. function QueryServiceLockStatusA;external advapi32 name 'QueryServiceLockStatusA';
  421. function QueryServiceLockStatusW;external advapi32 name 'QueryServiceLockStatusW';
  422. function QueryServiceLockStatus;external advapi32 name 'QueryServiceLockStatusA';
  423. function QueryServiceObjectSecurity;external advapi32 name 'QueryServiceObjectSecurity';
  424. function QueryServiceStatus;       external advapi32 name 'QueryServiceStatus';
  425. function RegisterServiceCtrlHandlerA;external advapi32 name 'RegisterServiceCtrlHandlerA';
  426. function RegisterServiceCtrlHandlerW;external advapi32 name 'RegisterServiceCtrlHandlerW';
  427. function RegisterServiceCtrlHandler;external advapi32 name 'RegisterServiceCtrlHandlerA';
  428. function SetServiceObjectSecurity; external advapi32 name 'SetServiceObjectSecurity';
  429. function SetServiceStatus;         external advapi32 name 'SetServiceStatus';
  430. function StartServiceCtrlDispatcherA;external advapi32 name 'StartServiceCtrlDispatcherA';
  431. function StartServiceCtrlDispatcherW;external advapi32 name 'StartServiceCtrlDispatcherW';
  432. function StartServiceCtrlDispatcher;external advapi32 name 'StartServiceCtrlDispatcherA';
  433. function StartServiceA;          external advapi32 name 'StartServiceA';
  434. function StartServiceW;          external advapi32 name 'StartServiceW';
  435. function StartService;          external advapi32 name 'StartServiceA';
  436. function UnlockServiceDatabase;    external advapi32 name 'UnlockServiceDatabase';
  437.  
  438. end.
  439.  
  440.